import api from '@/config/api'
import { showToast } from './common'

/**
 * 检查用户是否绑定了手机号
 * @param {boolean} showTips 是否显示提示
 * @param {string} redirectUrl 重定向URL
 * @returns {Promise<boolean>} 是否已绑定手机号
 */
export async function checkPhoneBinding(showTips = true, redirectUrl = '') {
  try {
    const res = await api.user.info()
    if (res.data && res.data.phone) {
      return true
    } else {
      if (showTips) {
        uni.showModal({
          title: '提示',
          content: '您尚未绑定手机号，绑定后才能继续操作',
          confirmText: '去绑定',
          cancelText: '暂不绑定',
          success: (result) => {
            if (result.confirm) {
              // 跳转到绑定手机号页面
              uni.navigateTo({
                url: `/pages/users/bind-phone/index?canSkip=false&redirect=${redirectUrl}`
              })
            }
          }
        })
      }
      return false
    }
  } catch (error) {
    if (showTips) {
      showToast('验证手机号状态失败')
    }
    return false
  }
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
export function isLoggedIn() {
  return !!getToken()
}

/**
 * 跳转到登录页
 * @param {string} redirectUrl 重定向URL
 */
export function goLogin(redirectUrl = '') {
  uni.navigateTo({
    url: `/pages/user/auth/login?redirect=${redirectUrl}`
  })
}

/**
 * 登出
 */
export function logout() {
  uni.removeStorageSync('token')
  uni.removeStorageSync('userInfo')
  uni.removeStorageSync('loginInfo')
  
  // 跳转到首页
  uni.switchTab({
    url: '/pages/index/index'
  })
}

/**
 * 获取用户信息
 * @returns {Promise<Object>} 用户信息
 */
export async function fetchUserInfo() {
  try {
    const res = await uni.$api.get('/user/info')
    if (res.code === 200 && res.data) {
      setUserInfo(res.data)
      return res.data
    }
    return null
  } catch (error) {
    console.error('获取用户信息失败:', error)
    return null
  }
}

/**
 * 处理登录成功
 * @param {Object} data 登录返回的数据
 */
export async function handleLoginSuccess(data) {
  try {
    // 保存token
    setToken(data.accessToken)

    // 保存用户信息
    setUserInfo({
      userId: data.userId,
      username: data.username,
      nickname: data.nickname,
      avatar: data.avatar
    })

    // 显示登录成功提示
    uni.showToast({
      title: '登录成功',
      icon: 'success'
    })

    // 延迟跳转，让用户看到提示
    setTimeout(() => {
      // 获取重定向地址
      const redirectUrl = uni.getStorageSync('loginRedirect')
      
      if (redirectUrl) {
        // 清除重定向地址
        uni.removeStorageSync('loginRedirect')
        // 跳转到重定向页面
        uni.reLaunch({
          url: redirectUrl
        })
      } else {
        // 获取当前页面栈
        const pages = getCurrentPages()
        // 如果当前页面是登录页，且页面栈大于1，则返回上一页
        if (pages.length > 1 && pages[pages.length - 1].route.includes('auth/login')) {
          uni.navigateBack()
        } else {
          // 否则跳转到首页
          uni.switchTab({
            url: '/pages/browse/home/index'
          })
        }
      }
    }, 1500)
  } catch (error) {
    console.error('登录处理失败:', error)
    uni.showToast({
      title: '登录失败',
      icon: 'error'
    })
  }
}

/**
 * 获取token
 * @returns {string|null} token字符串
 */
export function getToken() {
  return uni.getStorageSync('token') || null
}

/**
 * 设置token
 * @param {string} token token字符串
 */
export function setToken(token) {
  uni.setStorageSync('token', token)
}

/**
 * 移除token
 */
export function removeToken() {
  uni.removeStorageSync('token')
}

/**
 * 保存用户信息
 * @param {Object} userInfo 用户信息
 */
export function setUserInfo(userInfo) {
  uni.setStorageSync('userInfo', userInfo)
}

/**
 * 获取用户信息
 * @returns {Object|null} 用户信息
 */
export function getUserInfo() {
  return uni.getStorageSync('userInfo') || null
}

/**
 * 更新用户信息
 * @param {Object} newUserInfo 新的用户信息
 */
export function updateUserInfo(newUserInfo) {
  const oldUserInfo = getUserInfo() || {}
  const updatedUserInfo = {
    ...oldUserInfo,
    ...newUserInfo
  }
  uni.setStorageSync('userInfo', updatedUserInfo)
}

/**
 * 清除登录信息
 */
export function clearLoginInfo() {
  uni.removeStorageSync('token')
  clearUserInfo()
}

/**
 * 检查登录状态并跳转
 * @param {Object} options 页面参数
 * @returns {Boolean} 是否已登录
 */
export function checkLogin(options = {}) {
  if (!isLoggedIn()) {
    // 保存当前页面路径
    const pages = getCurrentPages()
    const currentPage = pages[pages.length - 1]
    let redirectUrl = currentPage.route
    
    // 如果有参数，拼接参数
    if (Object.keys(options).length > 0) {
      const params = []
      for (const key in options) {
        params.push(`${key}=${options[key]}`)
      }
      redirectUrl += `?${params.join('&')}`
    }
    
    // 存储重定向路径
    uni.setStorageSync('loginRedirect', `/${redirectUrl}`)
    
    // 跳转到登录页
    uni.navigateTo({
      url: '/pages/user/auth/login'
    })
    return false
  }
  return true
}

/**
 * 检查是否需要登录
 * @param {Array} requireLoginPages 需要登录的页面路径列表
 * @returns {Boolean} 当前页面是否需要登录
 */
export function needLogin(requireLoginPages = []) {
  const pages = getCurrentPages()
  const currentPage = pages[pages.length - 1]
  return requireLoginPages.some(page => currentPage.route.includes(page))
}

/**
 * 清除登录状态
 */
export function clearLoginState() {
  uni.removeStorageSync('token')
  uni.removeStorageSync('userInfo')
  uni.removeStorageSync('loginRedirect')
}

/**
 * 跳转到登录页面
 * @param {string} redirectUrl 登录后重定向的地址
 */
export function toLogin(redirectUrl) {
  if (redirectUrl) {
    uni.setStorageSync('loginRedirect', redirectUrl)
  }
  uni.navigateTo({
    url: '/pages/user/auth/login'
  })
}

/**
 * 清除用户信息
 */
export function clearUserInfo() {
  uni.removeStorageSync('userInfo')
} 